<?php
declare (strict_types=1);

namespace redis;

use Redis;

/**
 * redis操作类
 * 说明，任何为false的串，存在redis中都是空串。
 * 只有在key不存在时，才会返回false。
 * 这点可用于防止缓存穿透
 */
class RedisTools2
{
    public mixed $redis;
    public mixed $host;
    public mixed $port;
    public int $dbId = 0;
    //什么时候重新建立连接
    public mixed $expireTime;
    //当前权限认证码
    public mixed $auth;
    //单例模式
    static private $_instance;
    //连接属性数组
    public array $attr = array(
        //连接超时时间，redis配置文件中默认为300秒
        'timeout' => 30,
        //选择的数据库。
        'db_id' => 0,
    );

    /**
     * 定义构造方法
     * @param array $config
     * @param array $attr
     */
    private function __construct(array $config, array $attr = [])
    {
        $this->attr = array_merge($this->attr, $attr);
        $this->redis = new Redis();
        $this->port = intval($config['port'] ?: 6379);
        $this->host = $config['host'];
        $this->redis->connect($this->host, $this->port, $this->attr['timeout']);
        if ($config['password']) {
            $this->auth($config['password']);
            $this->auth = $config['password'];
        }
        $this->expireTime = time() + $this->attr['timeout'];
    }

    /**
     * 定义一个空方法防止被外部克隆
     * @return void
     */
    private function __clone()
    {
    }

    /**
     * 定义一个获取实例对象的方法
     * @param mixed $config
     * @param array $attr
     * @return RedisTools2
     */
    public static function getInstance(mixed $config, array $attr = ['db_id' => 2]): RedisTools2
    {
        if (!(self::$_instance instanceof self)) {
            static::$_instance = new self($config, $attr);
            static::$_instance->select($attr['db_id']);
        } elseif (time() > static::$_instance->expireTime) {
            static::$_instance->close();
            static::$_instance = new self($config, $attr);
            static::$_instance->select($attr['db_id']);
        }
        //返回实例对象
        return self::$_instance;
    }

    /*****************hash表操作函数*******************/

    /**
     * 得到hash表中一个字段的值
     * @param string $key
     * @param string $field
     * @return false|string
     */
    public function hGet(string $key, string $field): bool|string
    {
        return $this->redis->hGet($key, $field);
    }

    /**
     * 为hash表设定一个字段的值
     * @param string $key
     * @param string $field
     * @param string $value
     * @return bool|int
     */
    public function hSet(string $key, string $field, string $value): bool|int
    {
        return $this->redis->hSet($key, $field, $value);
    }

    /**
     * 判断hash表中指定field是不是存在
     * @param string $key
     * @param string $field
     * @return bool
     */
    public function hExists(string $key, string $field): bool
    {
        return $this->redis->hExists($key, $field);
    }

    /**
     * 删除hash表中指定字段(支持批量删除)
     * @param string $key
     * @param string $field
     * @return bool|int
     */
    public function hDel(string $key, string $field): bool|int
    {
        $fieldArr = explode(',', $field);
        $delNum = 0;
        foreach ($fieldArr as $row) {
            $row = trim($row);
            $delNum += $this->redis->hDel($key, $row);
        }
        return $delNum;
    }

    /**
     * 返回hash表元素个数
     * @param string $key
     * @return false|int
     */
    public function hLen(string $key): bool|int
    {
        return $this->redis->hLen($key);
    }

    /**
     * 为hash表设定一个字段的值,如果字段存在，返回false
     * @param string $key
     * @param string $field
     * @param string $value
     * @return bool
     */
    public function hSetNx(string $key, string $field, string $value): bool
    {
        return $this->redis->hSetNx($key, $field, $value);
    }

    /**
     * 为hash表多个字段设定值
     * @param string $key
     * @param array $value
     * @return bool
     */
    public function hMset(string $key, array $value): bool
    {
        return $this->redis->hMset($key, $value);
    }

    /**
     * 为hash表多个字段设定值
     * @param string $key
     * @param array|string $field
     * @return array
     */
    public function hMget(string $key, array|string $field): array
    {
        if (!is_array($field)) {
            $field = explode(',', $field);
        }
        return $this->redis->hMget($key, $field);
    }

    /**
     * 为hash表设这累加可以负数
     * @param string $key
     * @param string $field
     * @param int $value
     * @return int
     */
    public function hIncrBy(string $key, string $field, int $value): int
    {
        return $this->redis->hIncrBy($key, $field, $value);
    }

    /**
     * 返回所有hash表的所有字段
     * @param string $key
     * @return array
     */
    public function hKeys(string $key): array
    {
        return $this->redis->hKeys($key);
    }

    /**
     * 返回所有hash表的字段值,为一个索引数组
     * @param string $key
     * @return array
     */
    public function hVals(string $key): array
    {
        return $this->redis->hVals($key);
    }

    /**
     * 返回所有hash表的字段值,为一个关联数组
     * @param string $key
     * @return array
     */
    public function hGetAll(string $key): array
    {
        return $this->redis->hGetAll($key);
    }

    /*********************有序集合操作*********************/

    /**
     * 给当前集合添加一个元素,如果value已经存在,会更新order的值
     * @param string $key
     * @param mixed $order
     * @param mixed $value
     * @return int
     */
    public function zAdd(string $key, mixed $order, mixed $value): int
    {
        return $this->redis->zAdd($key, $order, $value);
    }

    /**
     * 删除值为value的元素
     * @param string $key
     * @param mixed $value
     * @return int
     */
    public function zRem(string $key, mixed $value): int
    {
        return $this->redis->zRem($key, $value);
    }

    /**
     * 集合以order递增排列后，0表示第一个元素，-1表示最后一个元素
     * @param string $key
     * @param int $start
     * @param int $end
     * @return array
     */
    public function zRange(string $key, int $start, int $end): array
    {
        return $this->redis->zRange($key, $start, $end);
    }

    /**
     * 集合以order递减排列后，0表示第一个元素，-1表示最后一个元素
     * @param string $key
     * @param int $start
     * @param int $end
     * @return array
     */
    public function zRevRange(string $key, int $start, int $end): array
    {
        return $this->redis->zRevRange($key, $start, $end);
    }

    /**
     * 集合以order递增排列后，返回指定order之间的元素。
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param string $key
     * @param int|string $start
     * @param int|string $end
     * @param array $option
     * @return array
     */
    public function zRangeByScore(string $key, int|string $start = '-inf', int|string $end = "+inf", array $option = []): array
    {
        return $this->redis->zRangeByScore($key, $start, $end, $option);
    }

    /**
     * 集合以order递减排列后，返回指定order之间的元素。
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param string $key
     * @param int|string $start
     * @param int|string $end
     * @param array $option
     * @return array
     */
    public function zRevRangeByScore(string $key, int|string $start = '-inf', int|string $end = "+inf", array $option = []): array
    {
        return $this->redis->zRevRangeByScore($key, $start, $end, $option);
    }

    /**
     * 返回order值在start和end之间的数量
     * @param string $key
     * @param string $start
     * @param string $end
     * @return int
     */
    public function zCount(string $key, string $start, string $end): int
    {
        return $this->redis->zCount($key, $start, $end);
    }

    /**
     * 返回值为value的order值
     * @param string $key
     * @param mixed $value
     * @return bool|float
     */
    public function zScore(string $key, mixed $value): float|bool
    {
        return $this->redis->zScore($key, $value);
    }

    /**
     * 返回集合以score递增加排序后，指定成员的排序号，从0开始
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function zRank(string $key, mixed $value): bool|int
    {
        return $this->redis->zRank($key, $value);
    }

    /**
     * 返回集合以score递增加排序后，指定成员的排序号，从0开始
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function zRevRank(string $key, mixed $value): bool|int
    {
        return $this->redis->zRevRank($key, $value);
    }

    /**
     * 删除集合中，score值在start end之间的元素　包括start end
     * min和max可以是-inf和+inf　表示最大值，最小值
     * @param string $key
     * @param string $start
     * @param string $end
     * @return int
     */
    public function zRemRangeByScore(string $key, string $start, string $end): int
    {
        return $this->redis->zRemRangeByScore($key, $start, $end);
    }

    /**
     * 返回集合元素个数
     * @param string $key
     * @return int
     */
    public function zCard(string $key): int
    {
        return $this->redis->zCard($key);
    }

    /*********************队列操作命令************************/

    /**
     * 在队列尾部插入一个元素
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function rPush(string $key, mixed $value): bool|int
    {
        return $this->redis->rPush($key, $value);
    }

    /**
     * 在队列尾部插入一个元素,如果key不存在，什么也不做
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function rPushx(string $key, mixed $value): bool|int
    {
        return $this->redis->rPushx($key, $value);
    }

    /**
     * 在队列头部插入一个元素
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function lPush(string $key, mixed $value): bool|int
    {
        return $this->redis->lPush($key, $value);
    }

    /**
     * 在队列头插入一个元素,如果key不存在，什么也不做
     * @param string $key
     * @param mixed $value
     * @return false|int
     */
    public function lPushx(string $key, mixed $value): bool|int
    {
        return $this->redis->lPushx($key, $value);
    }

    /**
     * 返回队列长度
     * @param string $key
     * @return bool|int
     */
    public function lLen(string $key): bool|int
    {
        return $this->redis->lLen($key);
    }

    /**
     * 返回队列指定区间的元素
     * @param string $key
     * @param int $start
     * @param int $end
     * @return array
     */
    public function lrange(string $key, int $start, int $end): array
    {
        return $this->redis->lrange($key, $start, $end);
    }

    /**
     * 返回队列中指定索引的元素
     * @param string $key
     * @param int $index
     * @return bool|mixed
     */
    public function lIndex(string $key, int $index): mixed
    {
        return $this->redis->lIndex($key, $index);
    }

    /**
     * 设定队列中指定index的值
     * @param string $key
     * @param int $index
     * @param string $value
     * @return bool
     */
    public function lSet(string $key, int $index, string $value): bool
    {
        return $this->redis->lSet($key, $index, $value);
    }

    /**
     * 删除值为vaule的count个元素
     * @param string $key
     * @param string $value
     * @param int $count
     * @return bool|int
     */
    public function lRem(string $key, string $value, int $count): bool|int
    {
        return $this->redis->lRem($key, $value, $count);
    }

    /**
     * 删除并返回队列中的头元素
     * @param string $key
     * @return bool|mixed
     */
    public function lPop(string $key): mixed
    {
        return $this->redis->lPop($key);
    }

    /**
     * 删除并返回队列中的尾元素
     * @param string $key
     * @return bool|mixed
     */
    public function rPop(string $key): mixed
    {
        return $this->redis->rPop($key);
    }

    /*************redis字符串操作命令*****************/

    /**
     * 设置一个key
     * @param string $key
     * @param mixed $value
     * @param int|array $timeout
     * @return bool
     */
    public function set(string $key, mixed $value, int|array $timeout): bool
    {
        return $this->redis->set($key, $value, $timeout);
    }

    /**
     * 得到一个key的值
     * @param string $key
     * @return false|mixed|string
     */
    public function get(string $key): mixed
    {
        return $this->redis->get($key);
    }

    /**
     * 设置一个有过期时间的key
     * @param string $key
     * @param int $ttl
     * @param mixed $value
     * @return bool
     */
    public function setex(string $key, int $ttl, mixed $value): bool
    {
        return $this->redis->setex($key, $ttl, $value);
    }

    /**
     * 设置一个key,如果key存在,不做任何操作
     * @param string $key
     * @param mixed $value
     * @param mixed $ttll
     * @return bool
     */
    public function setnx(string $key, mixed $value): bool
    {
        return $this->redis->setnx($key, $value);
    }

    /**
     * 批量设置key
     * @param array $array
     * @return bool
     */
    public function mset(array $array): bool
    {
        return $this->redis->mset($array);
    }

    /************* redis 无序集合操作命令 *****************/

    /**
     * 返回集合中所有元素
     * @param string $key
     * @return array
     */
    public function sMembers(string $key): array
    {
        return $this->redis->sMembers($key);
    }

    /**
     * 求2个集合的差集
     * @param string $key1
     * @param string $key2
     * @return array
     */
    public function sDiff(string $key1, string $key2): array
    {
        return $this->redis->sDiff($key1, $key2);
    }

    /**
     * 添加集合。由于版本问题，扩展不支持批量添加。这里做了封装
     * @param string $key
     * @param mixed $value
     * @return array
     */
    public function sAdd(string $key, mixed $value): array
    {
        if (!is_array($value)) {
            $arr = array($value);
        } else {
            $arr = $value;
        }
        $res = [];
        foreach ($arr as $k => $row) {
            $res[$k] = $this->redis->sAdd($key, $row);
        }
        return $res;
    }

    /**
     * 返回无序集合的元素个数
     * @param string $key
     * @return int
     */
    public function scard(string $key): int
    {
        return $this->redis->scard($key);
    }

    /**
     * 从集合中删除一个元素
     * @param string $key
     * @param mixed $value
     * @return int
     */
    public function srem(string $key, mixed $value): int
    {
        return $this->redis->srem($key, $value);
    }

    /************* redis管理操作命令 *****************/

    /**
     * 选择数据库
     * @param int $dbId
     * @return bool
     */
    public function select(int $dbId): bool
    {
        $this->dbId = $dbId;
        return $this->redis->select($dbId);
    }

    /**
     * 清空当前数据库
     * @return bool
     */
    public function flushDB(): bool
    {
        return $this->redis->flushDB();
    }

    /**
     * 返回当前库状态
     * @return array
     */
    public function info(): array
    {
        return $this->redis->info();
    }

    /**
     * 同步保存数据到磁盘
     * @return bool
     */
    public function save(): bool
    {
        return $this->redis->save();
    }

    /**
     * 异步保存数据到磁盘
     * @return bool
     */
    public function bgSave(): bool
    {
        return $this->redis->bgSave();
    }

    /**
     * 返回最后保存到磁盘的时间
     * @return int
     */
    public function lastSave(): int
    {
        return $this->redis->lastSave();
    }

    /**
     * 返回key,支持*多个字符，?一个字符,只有*表示全部
     * @param string $pattern
     * @return array
     */
    public function keys(string $pattern): array
    {
        return $this->redis->keys($pattern);
    }

    /**
     * 删除指定key
     * @param string $key
     * @return int
     */
    public function del(string $key): int
    {
        return $this->redis->del($key);
    }

    /**
     * 判断一个key值是不是存在
     * @param string $key
     * @return bool|int
     */
    public function exists(string $key): bool|int
    {
        return $this->redis->exists($key);
    }

    /**
     * 为一个key设定过期时间,单位为秒
     * @param string $key
     * @param int $ttl
     * @return bool
     */
    public function expire(string $key, int $ttl): bool
    {
        return $this->redis->expire($key, $ttl);
    }

    /**
     * 返回一个key还有多久过期,单位秒
     * @param string $key
     * @return bool|int
     */
    public function ttl(string $key): bool|int
    {
        return $this->redis->ttl($key);
    }

    /**
     * 设定一个key什么时候过期,time为一个时间戳
     * @param string $key
     * @param int $timestamp
     * @return bool
     */
    public function exprieAt(string $key, int $timestamp): bool
    {
        return $this->redis->expireAt($key, $timestamp);
    }

    /**
     * 关闭服务器链接
     * @return bool
     */
    public function close(): bool
    {
        return $this->redis->close();
    }

    /**
     * 返回当前数据库key数量
     * @return int
     */
    public function dbSize(): int
    {
        return $this->redis->dbSize();
    }

    /**
     * 返回一个随机key
     * @return string
     */
    public function randomKey(): string
    {
        return $this->redis->randomKey();
    }

    /**
     * 返回当前连接信息
     * @return array
     */
    public function getConnInfo(): array
    {
        return array(
            'host' => $this->host,
            'port' => $this->port,
            'auth' => $this->auth
        );
    }

    /*********************事务的相关方法************************/

    /**
     * 监控key,就是一个或多个key添加一个乐观锁
     * 在此期间如果key的值如果发生的改变，刚不能为key设定值
     * 可以重新取得Key的值
     * @param string $key
     * @return void
     */
    public function watch(string $key)
    {
        $this->redis->watch($key);
    }

    /**
     * 取消当前链接对所有key的watch
     * EXEC命令或DISCARD命令先被执行了的话，那么就不需要再执行 UNWATCH了
     * @return void
     */
    public function unwatch()
    {
        $this->redis->unwatch();
    }

    /**
     * 开启一个事务
     * 事务的调用有两种模式Redis::MULTI和Redis::PIPELINE，
     * 默认是Redis::MULTI模式，
     * Redis::PIPELINE管道模式速度更快，但没有任何保证原子性有可能造成数据的丢失
     * @param int $type
     * @return Redis
     */
    public function multi(int $type = Redis::MULTI): Redis
    {
        return $this->redis->multi($type);
    }

    /**
     * 执行一个事务
     * 收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行
     * @return array|void
     */
    public function exec()
    {
        return $this->redis->exec();
    }

    /**
     * 回滚一个事务
     * @return void
     */
    public function discard()
    {
        $this->redis->discard();
    }

    /**
     * 测试当前链接是不是已经失效
     * @return bool|string
     * @throws \RedisException
     */
    public function ping(): bool|string
    {
        return $this->redis->ping();
    }

    /**
     * 使用密码验证连接
     * @param string $password
     * @return bool
     */
    public function auth(string $password): bool
    {
        return $this->redis->auth($password);
    }

}
